module klang.klang.转换工厂.中间码转换.工具.工具_;
import 全局;
import std.conv: ·to = to;
import ··Klang节点_ = klang.klang.语法节点.Klang节点_;
import ··类型_ = klang.编译.类型.类型_;
import klang.编译.类型.类型_: 基工厂_ = 节点工厂_, 基础符号_ = 符号_, 转换上下文_, 转换函数_, 输出解析器_, 转换支持_, 程序主机接口_, 打印助手_, EmitHint, IEmitTextWriter, 打印机_, 符号表_;
import klang.编译.输出节点.输出节点_: EmitFlags, addEmitFlags, getOriginalNode_1;
import klang.编译.语法节点.节点_: 基础节点_ = 节点_, 基础源文件_ = 源文件_, 节点数组_;
import klang.klang.语法节点.Klang节点_: 节点_ = Klang节点_, 令牌_ = Klang令牌_, 源文件_ = Klang源文件_, 标识符_ = Klang标识符_, 修饰符_, 语句_, 版本语句_, 表达式_, 块_, 测试单元语句_, 断言语句_, 变量声明_, 导入从版本成员_, 导入版本成员_, 导入成员块_, 导入从成员块_, 导入从成员_, 导入成员_, 数组类型节点_ = 数组类型_, 数字字面量_ = klang数字字面量_, 程序声明_, 函数声明_, 形参声明_, 对象声明_, 方法声明_, 构建声明_, 如果语句_, 返回语句_, 抛出语句_, 属性声明_, 继承子句_, 结构声明节点_ = 结构声明_, 调用表达式_, 类型断言表达式_, 符号引用表达式_, 前缀一元表达式_, 二元表达式_, 限定名_, 类型引用_, 类型形参_, 获取源文件;
import klang.klang.检查.klang检查_: Klang转换支持_, combineTypeMappers, instantiateType, instantiateTypes, 获取节点Id, 获取符号Id, 获取类型Id, 获取签名Id, 获取字面量类型的基约束类型, 获取父符号, 创建泛型引用, getTypeArguments, 获取签名从签名声明, getReturnTypeOfSignature, 获取类型节点的类型, 计算类型断言表达式, 获取源文件的程序声明, 获取符号的声明类型;
import klang.编译.输出工具.输出工具_: EmitTextWriter, 创建文本写;
import klang.klang.类型.klang类型_: 符号_ = Klang符号_, 类型_ = Klang类型_, 签名_ = Klang签名_, KSK, 编译选项_, 节点标志_, 节点扩展_, 节点检查标志_, 类型映射_, 类型标志_, Klang输出种类_, Klang打印选项_, 符号标志_, 复合标志_, klang解析的模块名称_, 内置类型_, 内部符号名_;
import klang.编译.核心.核心_: 词典_, 整数_, 创建数组, 创建词典, 返回零值, 映射, 循环每个, 最小, 获取正规文件名函数_, 查找索引, 结尾包含, 文本包含, 按字符分割, 从后查找字符索引, 部分, 连接, 十六进制编码;
import klang.编译.节点访问.访问节点_: Visitor, visitNode, visitNodes;
import klang.编译.类型.枚举值.枚举值_: 字符_;
import klang.编译.路径.路径_: 获取正规化路径组件组, 获取目录路径;
import klang.klang.节点工厂.Klang工厂_: 节点工厂标志_, 节点工厂_ = Klang节点工厂_;
import klang.klang.转换工厂.转换工具.Klang转换工具_: 获取输出文件名;
import klang.klang.打印输出.Klang打印输出_: 创建打印机 = klang创建打印机;
import klang.编译.工具.工具_: getParseTreeNode_1, 创建符号表;
import klang.klang.转换工厂.中间码转换.类型.中间码类型_: 未整合源文件_;
节点工厂_ fc;
Klang转换支持_ K;
打印机_ 打印机;
void 初始化工具(Klang转换支持_ 支持) {
    .fc = new 节点工厂_(节点工厂标志_.合成工厂_, 节点标志_.Synthesized);
    .K = 支持;
}
基础节点_ 返回空() {
    return 返回零值!(基础节点_)();
}
基础节点_ 设置输出标志(基础节点_ n) {
    if (n is ··null!(基础节点_)) {
        return n;
    }
    return addEmitFlags(n, EmitFlags.不缩进合成块_);
}
节点扩展_ 获取节点扩展(基础节点_ 节点) {
    if (节点 is ··null!(基础节点_)) {
        return ··null!(节点扩展_);
    }
    节点 = getOriginalNode_1(节点);
    if (节点.扩展 !is ··null!(void*)) {
        return (cast(节点扩展_)(节点.扩展));
    }
    return ··null!(节点扩展_);
}
符号_ 获取解析符号(基础节点_ 节点) {
    if (节点 is ··null!(基础节点_)) {
        return ··null!(符号_);
    }
    节点扩展_ 扩展 = .获取节点扩展(节点);
    if (扩展 !is ··null!(节点扩展_)) {
        return 扩展.解析符号;
    }
    return ··null!(符号_);
}
符号_ 获取节点符号(基础节点_ 节点) {
    节点 = getOriginalNode_1(节点);
    return (cast(符号_)(节点.符号));
}
dstring 获取符号文本Id(基础符号_ s) {
    return ·to!(dstring)(获取符号Id((cast(符号_)(s))));
}
dstring 获取类型文本Id(类型_ t) {
    return ·to!(dstring)(获取类型Id(t));
}
dstring 获取节点文本Id(基础节点_ n) {
    return ·to!(dstring)(获取节点Id(n));
}
dstring 获取签名文本Id(签名_ n) {
    return ·to!(dstring)(获取签名Id(n));
}
基础节点_ 获取原始节点(基础节点_ n) {
    return getParseTreeNode_1(n);
}
符号_ 获取声明节点的符号(节点_ n) {
    return (cast(符号_)(.获取原始节点(n).符号));
}
节点数组_!(基础节点_) 访问节点数组(节点数组_!(基础节点_) ns, Visitor v) {
    return visitNodes!(基础节点_)(ns, cast(Visitor)(v));
}
dstring 获取结构类型类型信息碎裂名称(结构声明节点_ n) {
    dstring 输出 = "TypeInfo_S"d;
    dstring mangledName = .碎裂(n);
    输出 = 输出 ~ mangledName;
    输出 = "_D"d ~ ·to!(dstring)(输出.length) ~ 输出 ~ "6__initZ"d;
    return 输出;
}
符号_ COB_TypeInfo(符号表_ 符号表) {
    dstring 名称 = "object.TypeInfo"d;
    符号_ 符号;
    if (符号表.具有(名称)) {
        符号 = (cast(符号_)(符号表.获取(名称)));
        if ((符号.标志 & 符号标志_.符号占位符_) == 0) {
            return 符号;
        }
    }
    符号表_ 结构体成员 = 创建符号表();
    属性声明_ __vptr = fc.创建属性声明(fc.创建标识符("__vptr"d), fc.创建指针类型(fc.创建数组类型(fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)), fc.创建字面量类型(fc.创建数字字面量(19, 节点标志_.无)))));
    .创建符号及附加声明(符号标志_.属性_, "__vptr"d, __vptr, 结构体成员, K.创建指针类型(K.创建数组类型(K.获取内置类型(内置类型_.无值指针类型), K.创建正整数字面量类型(类型标志_.正整数64_, 19))));
    属性声明_ __monitor = fc.创建属性声明(fc.创建标识符("__monitor"d), fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)));
    .创建符号及附加声明(符号标志_.属性_, "__monitor"d, __monitor, 结构体成员, K.获取内置类型(内置类型_.无值指针类型));
    对象声明_ 对象声明 = fc.创建对象声明(fc.创建文本标识符(名称), ·to!(节点数组_!(节点_))(fc.f·创建节点数组!(属性声明_)([__vptr, __monitor], false)));
    if (符号 is ··null!(符号_)) {
        符号 = .创建符号及附加声明(符号标志_.对象_, 名称, 对象声明, 符号表);
    }
    else {
        assert((符号.标志 & 符号标志_.符号占位符_) != 0, "错误了"c);
        .设置符号关系(符号, 对象声明, 符号表);
    }
    return .设置声明类型(符号, 结构体成员);
}
符号_ COB_TypeInfo_Class(符号表_ 符号表) {
    /**
     结构 "object.TypeInfo_Class" {
        __vptr : [22 x i8*]*,
        __monitor: i8*,

        m_init: { i64, i8* },
        name: { i64, i8* },
        vptr : { i64, i8** },
        interfaces: { i64, %object.Interface* },
        base_:  %object.TypeInfo_Class*,
        destructor: i8*,
        classInvariant: void (%object.Object*)*,
        m_flags: i32, __n: [4 x i8], // 旗帜低位
        deallocator: i8*,
        m_offTi: { i64, %object.OffsetTypeInfo* },
        defaultConstructor: void (%object.Object*)*,
        m_RTInfo i8*
    }
    */
    dstring 名称 = "object.TypeInfo_Class"d;
    符号_ 符号;
    if (符号表.具有(名称)) {
        符号 = (cast(符号_)(符号表.获取(名称)));
        if ((符号.标志 & 符号标志_.符号占位符_) == 0) {
            return 符号;
        }
    }
    符号表_ 结构体成员 = 创建符号表();
    // __vptr : [22 x i8*]*, 
    属性声明_ __vptr = fc.创建属性声明(fc.创建标识符("__vptr"d), fc.创建指针类型(fc.创建数组类型(fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)), fc.创建字面量类型(fc.创建数字字面量(22, 节点标志_.无)))));
    .创建符号及附加声明(符号标志_.属性_, "__vptr"d, __vptr, 结构体成员, K.创建指针类型(K.创建数组类型(K.获取内置类型(内置类型_.无值指针类型), K.创建正整数字面量类型(类型标志_.正整数64_, 22))));
    // __monitor: i8*,
    属性声明_ __monitor = fc.创建属性声明(fc.创建标识符("__monitor"d), fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)));
    .创建符号及附加声明(符号标志_.属性_, "__monitor"d, __monitor, 结构体成员, K.获取内置类型(内置类型_.无值指针类型));
    // m_init: { i64, i8* }, 
    属性声明_ m_init = fc.创建属性声明(fc.创建标识符("m_init"d), fc.创建动态数组类型(fc.创建关键字类型节点(KSK.正整数8_)));
    .创建符号及附加声明(符号标志_.属性_, "m_init"d, m_init, 结构体成员, K.创建动态数组类型(K.获取内置类型(内置类型_.正整数8类型)));
    // name: { i64, i8* }, 
    属性声明_ name = fc.创建属性声明(fc.创建标识符("name"d), fc.创建动态数组类型(fc.创建关键字类型节点(KSK.字符8_)));
    .创建符号及附加声明(符号标志_.属性_, "name"d, name, 结构体成员, K.创建动态数组类型(K.获取内置类型(内置类型_.字符8类型)));
    // vptr : { i64, i8** }, 
    属性声明_ vptr = fc.创建属性声明(fc.创建标识符("vptr"d), fc.创建动态数组类型(fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_))));
    .创建符号及附加声明(符号标志_.属性_, "vptr"d, vptr, 结构体成员, K.创建动态数组类型(K.获取内置类型(内置类型_.无值指针类型)));
    类型引用_ OIN = fc.创建类型引用(fc.创建起始限定名(fc.创建文本标识符("object.Interface"d)));
    符号_ OIS = .获取类型引用符号或占位符(符号表, "object.Interface"d, OIN);
    if (OIS is ··null!(符号_)) {
        类型_ 声明类型 = K.创建站位结构类型();
        .创建类型引用符号占位符(符号表, 符号标志_.结构_, "object.Interface"d, OIN, 声明类型);
    }
    // interfaces: { i64, %object.Interface* },
    属性声明_ interfaces = fc.创建属性声明(fc.创建标识符("interfaces"d), fc.创建动态数组类型(OIN));
    .创建符号及附加声明(符号标志_.属性_, "interfaces"d, interfaces, 结构体成员, K.创建动态数组类型(.获取合成节点扩展(OIN).解析类型));
    类型引用_ TIC = fc.创建类型引用(fc.创建起始限定名(fc.创建文本标识符("object.TypeInfo_Class"d)));
    符号_ TICS = .获取类型引用符号或占位符(符号表, "object.TypeInfo_Class"d, TIC);
    if (TICS is ··null!(符号_)) {
        类型_ 声明类型 = K.创建站位结构类型();
        .创建类型引用符号占位符(符号表, 符号标志_.结构_, "object.TypeInfo_Class"d, TIC, 声明类型);
    }
    // base_:  %object.TypeInfo_Class*,
    属性声明_ base_ = fc.创建属性声明(fc.创建标识符("base"d), fc.创建指针类型(TIC));
    .创建符号及附加声明(符号标志_.属性_, "base"d, base_, 结构体成员, K.创建指针类型(.获取合成节点扩展(TIC).解析类型));
    // destructor: i8*,
    属性声明_ destructor = fc.创建属性声明(fc.创建标识符("destructor"d), fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)));
    .创建符号及附加声明(符号标志_.属性_, "destructor"d, destructor, 结构体成员, K.获取内置类型(内置类型_.无值指针类型));
    类型引用_ OON = fc.创建类型引用(fc.创建起始限定名(fc.创建文本标识符("object.Object"d)));
    符号_ OONS = .获取类型引用符号或占位符(符号表, "object.Object"d, OON);
    if (OONS is ··null!(符号_)) {
        类型_ 声明类型 = K.创建站位结构类型();
        .创建类型引用符号占位符(符号表, 符号标志_.结构_, "object.Object"d, OON, 声明类型);
    }
    符号_ FS = .创建函数类型节点([fc.创建形参声明(fc.创建标识符("p"d), fc.创建指针类型(OON))], fc.创建关键字类型节点(KSK.无值_));
    // classInvariant: void (%object.Object*)*,
    属性声明_ classInvariant = fc.创建属性声明(fc.创建标识符("classInvariant"d), fc.创建指针类型((cast(节点_)(FS.值声明))));
    .创建符号及附加声明(符号标志_.属性_, "classInvariant"d, classInvariant, 结构体成员, K.创建指针类型(FS.类型));
    // m_flags: i32, 
    属性声明_ m_flags = fc.创建属性声明(fc.创建标识符("m_flags"d), fc.创建关键字类型节点(KSK.正整数32_));
    .创建符号及附加声明(符号标志_.属性_, "m_flags"d, m_flags, 结构体成员, K.获取内置类型(内置类型_.正整数32类型));
    // [4 x i8]
    // 这个还没有;
    属性声明_ __n = fc.创建属性声明(fc.创建标识符("__n"d), fc.创建数组类型(fc.创建关键字类型节点(KSK.正整数8_), fc.创建字面量类型(fc.创建数字字面量(4, 节点标志_.无))));
    .创建符号及附加声明(符号标志_.属性_, "__n"d, __n, 结构体成员, K.创建数组类型(K.获取内置类型(内置类型_.正整数8类型), K.创建正整数字面量类型(类型标志_.正整数64_, 4)));
    // deallocator: i8*, 
    属性声明_ deallocator = fc.创建属性声明(fc.创建标识符("deallocator"d), fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)));
    .创建符号及附加声明(符号标志_.属性_, "deallocator"d, deallocator, 结构体成员, K.获取内置类型(内置类型_.无值指针类型));
    类型引用_ FTI = fc.创建类型引用(fc.创建起始限定名(fc.创建文本标识符("object.OffsetTypeInfo"d)));
    符号_ FTIS = .获取类型引用符号或占位符(符号表, "object.OffsetTypeInfo"d, TIC);
    if (FTIS is ··null!(符号_)) {
        类型_ 声明类型 = K.创建站位结构类型();
        .创建类型引用符号占位符(符号表, 符号标志_.结构_, "object.OffsetTypeInfo"d, FTI, 声明类型);
    }
    // m_offTi: { i64, %object.OffsetTypeInfo* }, 
    属性声明_ m_offTi = fc.创建属性声明(fc.创建标识符("m_offTi"d), fc.创建动态数组类型(FTI));
    .创建符号及附加声明(符号标志_.属性_, "m_offTi"d, m_offTi, 结构体成员, K.创建动态数组类型(.获取合成节点扩展(FTI).解析类型));
    类型引用_ OON2 = fc.创建类型引用(fc.创建起始限定名(fc.创建文本标识符("object.Object"d)));
    符号_ OONS2 = .获取类型引用符号或占位符(符号表, "object.Object"d, OON2);
    if (OONS2 is ··null!(符号_)) {
        类型_ 声明类型 = K.创建站位结构类型();
        .创建类型引用符号占位符(符号表, 符号标志_.结构_, "object.Object"d, OON2, 声明类型);
    }
    符号_ FS2 = .创建函数类型节点([fc.创建形参声明(fc.创建标识符("p"d), fc.创建指针类型(OON2))], fc.创建关键字类型节点(KSK.无值_));
    // defaultConstructor: void (%object.Object*)*,
    属性声明_ defaultConstructor = fc.创建属性声明(fc.创建标识符("defaultConstructor"d), fc.创建指针类型((cast(节点_)(FS2.值声明))));
    .创建符号及附加声明(符号标志_.属性_, "defaultConstructor"d, defaultConstructor, 结构体成员, K.创建指针类型(FS2.类型));
    // m_RTInfo i8*
    属性声明_ m_RTInfo = fc.创建属性声明(fc.创建标识符("m_RTInfo"d), fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)));
    .创建符号及附加声明(符号标志_.属性_, "m_RTInfo"d, m_RTInfo, 结构体成员, K.获取内置类型(内置类型_.无值指针类型));
    对象声明_ 对象声明 = fc.创建对象声明(fc.创建文本标识符(名称), ·to!(节点数组_!(节点_))(fc.f·创建节点数组!(属性声明_)([__vptr, __monitor, m_init, name, vptr, interfaces, base_, destructor,
        classInvariant, m_flags, __n, deallocator, m_offTi, defaultConstructor, m_RTInfo
    ], false)));
    if (符号 is ··null!(符号_)) {
        符号 = .创建符号及附加声明(符号标志_.对象_, 名称, 对象声明, 符号表);
    }
    else {
        assert((符号.标志 & 符号标志_.符号占位符_) != 0, "错误了"c);
        .设置符号关系(符号, 对象声明, 符号表);
    }
    return .设置声明类型(符号, 结构体成员);
}
符号_ COB_TypeInfo_Struct(符号表_ 符号表) {
    /**
    结构 "object.TypeInfo_Struct" {
        __vptr : [19 x i8*]*,
        __monitor: i8*,
        name: { i64, i8* },
        m_init: { i64, i8* },
        xtoHash: i64 (i8*)*,
        xopEquals: i1 (i8*, i8*)*,
        xopCmp:  i32 (i8*, i8*)*,
        xtoString: { i64, i8* } (i8*)*,
        m_flags: i32, [4 x i8],
        xdtorti|xdtor: void (i8*)*,
        xpostblit: void (i8*)*,
        m_align: i32, [4 x i8],
        m_arg1: %object.TypeInfo*,
        m_arg2: %object.TypeInfo*,
        m_RTInfo: i8*
    }
    */
    dstring 名称 = "object.TypeInfo_Struct"d;
    符号_ 符号;
    if (符号表.具有(名称)) {
        符号 = (cast(符号_)(符号表.获取(名称)));
        if ((符号.标志 & 符号标志_.符号占位符_) == 0) {
            return 符号;
        }
    }
    符号表_ 结构体成员 = 创建符号表();
    // __vptr : [19 x i8*]*, 
    属性声明_ __vptr = fc.创建属性声明(fc.创建标识符("__vptr"d), fc.创建指针类型(fc.创建数组类型(fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)), fc.创建字面量类型(fc.创建数字字面量(19, 节点标志_.无)))));
    .创建符号及附加声明(符号标志_.属性_, "__vptr"d, __vptr, 结构体成员, K.创建指针类型(K.创建数组类型(K.获取内置类型(内置类型_.无值指针类型), K.创建正整数字面量类型(类型标志_.正整数64_, 19))));
    // __monitor: i8*,
    属性声明_ __monitor = fc.创建属性声明(fc.创建标识符("__monitor"d), fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)));
    .创建符号及附加声明(符号标志_.属性_, "__monitor"d, __monitor, 结构体成员, K.获取内置类型(内置类型_.无值指针类型));
    // name: { i64, i8* }, 
    属性声明_ name = fc.创建属性声明(fc.创建标识符("name"d), fc.创建动态数组类型(fc.创建关键字类型节点(KSK.字符8_)));
    .创建符号及附加声明(符号标志_.属性_, "name"d, name, 结构体成员, K.创建动态数组类型(K.获取内置类型(内置类型_.字符8类型)));
    // m_init: { i64, i8* }, 
    属性声明_ m_init = fc.创建属性声明(fc.创建标识符("m_init"d), fc.创建动态数组类型(fc.创建关键字类型节点(KSK.正整数8_)));
    .创建符号及附加声明(符号标志_.属性_, "m_init"d, m_init, 结构体成员, K.创建动态数组类型(K.获取内置类型(内置类型_.正整数8类型)));
    // xtoHash: i64 (i8*)*,
    符号_ FS = .创建函数类型节点([fc.创建形参声明(fc.创建标识符("p"d), fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)))], fc.创建关键字类型节点(KSK.正整数64_));
    属性声明_ xtoHash = fc.创建属性声明(fc.创建标识符("xtoHash"d), fc.创建指针类型((cast(节点_)(FS.值声明))));
    .创建符号及附加声明(符号标志_.属性_, "xtoHash"d, xtoHash, 结构体成员, K.创建指针类型(FS.类型));
    // xopEquals: i1 (i8*, i8*)*, 
    符号_ FS2 = .创建函数类型节点([fc.创建形参声明(fc.创建标识符("p0"d), fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_))), fc.创建形参声明(fc.创建标识符("p1"d), fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)))], fc.创建关键字类型节点(KSK.真假_));
    属性声明_ xopEquals = fc.创建属性声明(fc.创建标识符("xopEquals"d), fc.创建指针类型((cast(节点_)(FS2.值声明))));
    .创建符号及附加声明(符号标志_.属性_, "xopEquals"d, xopEquals, 结构体成员, K.创建指针类型(FS2.类型));
    // xopCmp:  i32 (i8*, i8*)*, 
    符号_ FS3 = .创建函数类型节点([fc.创建形参声明(fc.创建标识符("p0"d), fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_))), fc.创建形参声明(fc.创建标识符("p1"d), fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)))], fc.创建关键字类型节点(KSK.正整数32_));
    属性声明_ xopCmp = fc.创建属性声明(fc.创建标识符("xopCmp"d), fc.创建指针类型((cast(节点_)(FS3.值声明))));
    .创建符号及附加声明(符号标志_.属性_, "xopCmp"d, xopCmp, 结构体成员, K.创建指针类型(FS3.类型));
    // xtoString: { i64, i8* } (i8*)*, 
    符号_ FS4 = .创建函数类型节点([fc.创建形参声明(fc.创建标识符("p"d), fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)))], fc.创建动态数组类型(fc.创建关键字类型节点(KSK.字符8_)));
    属性声明_ xtoString = fc.创建属性声明(fc.创建标识符("xtoString"d), fc.创建指针类型((cast(节点_)(FS4.值声明))));
    .创建符号及附加声明(符号标志_.属性_, "xtoString"d, xtoString, 结构体成员, K.创建指针类型(FS4.类型));
    // m_flags: i32, 
    属性声明_ m_flags = fc.创建属性声明(fc.创建标识符("m_flags"d), fc.创建关键字类型节点(KSK.正整数32_));
    .创建符号及附加声明(符号标志_.属性_, "m_flags"d, m_flags, 结构体成员, K.获取内置类型(内置类型_.正整数32类型));
    // [4 x i8]
    // 这个还没有;
    属性声明_ __n = fc.创建属性声明(fc.创建标识符("__n"d), fc.创建数组类型(fc.创建关键字类型节点(KSK.正整数8_), fc.创建字面量类型(fc.创建数字字面量(4, 节点标志_.无))));
    .创建符号及附加声明(符号标志_.属性_, "__n"d, __n, 结构体成员, K.创建数组类型(K.获取内置类型(内置类型_.正整数8类型), K.创建正整数字面量类型(类型标志_.正整数64_, 4)));
    // xdtorti|xdtor: void (i8*)*,
    符号_ FS5 = .创建函数类型节点([fc.创建形参声明(fc.创建标识符("p"d), fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)))], fc.创建关键字类型节点(KSK.无值_));
    属性声明_ xdtorti_xdtor = fc.创建属性声明(fc.创建标识符("xdtorti_xdtor"d), fc.创建指针类型((cast(节点_)(FS5.值声明))));
    .创建符号及附加声明(符号标志_.属性_, "xdtorti_xdtor"d, xdtorti_xdtor, 结构体成员, K.创建指针类型(FS5.类型));
    // xpostblit: void (i8*)*, 
    符号_ FS6 = .创建函数类型节点([fc.创建形参声明(fc.创建标识符("p"d), fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)))], fc.创建关键字类型节点(KSK.无值_));
    属性声明_ xpostblit = fc.创建属性声明(fc.创建标识符("xpostblit"d), fc.创建指针类型((cast(节点_)(FS6.值声明))));
    .创建符号及附加声明(符号标志_.属性_, "xpostblit"d, xpostblit, 结构体成员, K.创建指针类型(FS6.类型));
    // m_align: i32, [4 x i8], 
    属性声明_ m_align = fc.创建属性声明(fc.创建标识符("m_align"d), fc.创建关键字类型节点(KSK.正整数32_));
    .创建符号及附加声明(符号标志_.属性_, "m_align"d, m_align, 结构体成员, K.获取内置类型(内置类型_.正整数32类型));
    属性声明_ __n2 = fc.创建属性声明(fc.创建标识符("__n2"d), fc.创建数组类型(fc.创建关键字类型节点(KSK.正整数8_), fc.创建字面量类型(fc.创建数字字面量(4, 节点标志_.无))));
    .创建符号及附加声明(符号标志_.属性_, "__n2"d, __n2, 结构体成员, K.创建数组类型(K.获取内置类型(内置类型_.正整数8类型), K.创建正整数字面量类型(类型标志_.正整数64_, 4)));
    类型引用_ TIC = fc.创建类型引用(fc.创建起始限定名(fc.创建文本标识符("object.TypeInfo"d)));
    符号_ TICS = .获取类型引用符号或占位符(符号表, "object.TypeInfo"d, TIC);
    if (TICS is ··null!(符号_)) {
        类型_ 声明类型 = K.创建站位结构类型();
        .创建类型引用符号占位符(符号表, 符号标志_.结构_, "object.TypeInfo"d, TIC, 声明类型);
    }
    // m_arg1: %object.TypeInfo*,
    属性声明_ m_arg1 = fc.创建属性声明(fc.创建标识符("m_arg1"d), fc.创建指针类型(TIC));
    .创建符号及附加声明(符号标志_.属性_, "m_arg1"d, m_arg1, 结构体成员, K.创建指针类型(.获取合成节点扩展(TIC).解析类型));
    // m_arg2: %object.TypeInfo*,
    属性声明_ m_arg2 = fc.创建属性声明(fc.创建标识符("m_arg2"d), fc.创建指针类型(TIC));
    .创建符号及附加声明(符号标志_.属性_, "m_arg2"d, m_arg2, 结构体成员, K.创建指针类型(.获取合成节点扩展(TIC).解析类型));
    // m_RTInfo i8*
    属性声明_ m_RTInfo = fc.创建属性声明(fc.创建标识符("m_RTInfo"d), fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)));
    .创建符号及附加声明(符号标志_.属性_, "m_RTInfo"d, m_RTInfo, 结构体成员, K.获取内置类型(内置类型_.无值指针类型));
    对象声明_ 对象声明 = fc.创建对象声明(fc.创建文本标识符(名称), ·to!(节点数组_!(节点_))(fc.f·创建节点数组!(属性声明_)([__vptr, __monitor, name, m_init, xtoHash, xopEquals, xopCmp, xtoString, m_flags, __n, xdtorti_xdtor, xpostblit, m_align, __n2, m_arg1, m_arg2, m_RTInfo], false)));
    if (符号 is ··null!(符号_)) {
        符号 = .创建符号及附加声明(符号标志_.对象_, 名称, 对象声明, 符号表);
    }
    else {
        assert((符号.标志 & 符号标志_.符号占位符_) != 0, "错误了"c);
        .设置符号关系(符号, 对象声明, 符号表);
    }
    return .设置声明类型(符号, 结构体成员);
}
符号_ COB_Interface(符号表_ 符号表) {
    /**
    结构 "object.Interface" {
        classinfo: %object.TypeInfo_Class*,
        vtbl: { i64, i8** },
        offset: i64
    }
    */
    dstring 名称 = "object.Interface"d;
    符号_ 符号;
    if (符号表.具有(名称)) {
        符号 = (cast(符号_)(符号表.获取(名称)));
        if ((符号.标志 & 符号标志_.符号占位符_) == 0) {
            return 符号;
        }
    }
    符号表_ 结构体成员 = 创建符号表();
    类型引用_ TIC = fc.创建类型引用(fc.创建起始限定名(fc.创建文本标识符("object.TypeInfo_Class"d)));
    符号_ TICS = .获取类型引用符号或占位符(符号表, "object.TypeInfo_Class"d, TIC);
    if (TICS is ··null!(符号_)) {
        类型_ 声明类型 = K.创建站位结构类型();
        .创建类型引用符号占位符(符号表, 符号标志_.结构_, "object.TypeInfo_Class"d, TIC, 声明类型);
    }
    // classinfo:  %object.TypeInfo_Class*,
    属性声明_ classinfo = fc.创建属性声明(fc.创建标识符("classinfo"d), fc.创建指针类型(TIC));
    .创建符号及附加声明(符号标志_.属性_, "classinfo"d, classinfo, 结构体成员, K.创建指针类型(.获取合成节点扩展(TIC).解析类型));
    // vptr : { i64, i8** }, 
    属性声明_ vptr = fc.创建属性声明(fc.创建标识符("vptr"d), fc.创建动态数组类型(fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_))));
    .创建符号及附加声明(符号标志_.属性_, "vptr"d, vptr, 结构体成员, K.创建动态数组类型(K.获取内置类型(内置类型_.无值指针类型)));
    // offset: i64, 
    属性声明_ offset = fc.创建属性声明(fc.创建标识符("offset"d), fc.创建关键字类型节点(KSK.正整数64_));
    .创建符号及附加声明(符号标志_.属性_, "offset"d, offset, 结构体成员, K.获取内置类型(内置类型_.正整数64类型));
    结构声明节点_ 结构声明 = fc.创建结构声明(fc.创建文本标识符(名称), ·to!(节点数组_!(节点_))(fc.f·创建节点数组!(属性声明_)([classinfo, vptr, offset], false)));
    if (符号 is ··null!(符号_)) {
        符号 = .创建符号及附加声明(符号标志_.结构_, 名称, 结构声明, 符号表);
    }
    else {
        assert((符号.标志 & 符号标志_.符号占位符_) != 0, "错误了"c);
        .设置符号关系(符号, 结构声明, 符号表);
    }
    return .设置声明类型(符号, 结构体成员);
}
符号_ COB_OffsetTypeInfo(符号表_ 符号表) {
    /**
        结构 "object.OffsetTypeInfo" {
            offset: i64
            ti: %object.TypeInfo*,
        }
    */
    dstring 名称 = "object.OffsetTypeInfo"d;
    符号_ 符号;
    if (符号表.具有(名称)) {
        符号 = (cast(符号_)(符号表.获取(名称)));
        if ((符号.标志 & 符号标志_.符号占位符_) == 0) {
            return 符号;
        }
    }
    符号表_ 结构体成员 = 创建符号表();
    类型引用_ TIC = fc.创建类型引用(fc.创建起始限定名(fc.创建文本标识符("object.TypeInfo"d)));
    符号_ TICS = .获取类型引用符号或占位符(符号表, "object.TypeInfo"d, TIC);
    if (TICS is ··null!(符号_)) {
        类型_ 声明类型 = K.创建站位结构类型();
        .创建类型引用符号占位符(符号表, 符号标志_.结构_, "object.TypeInfo"d, TIC, 声明类型);
    }
    // offset: i64, 
    属性声明_ offset = fc.创建属性声明(fc.创建标识符("offset"d), fc.创建关键字类型节点(KSK.正整数64_));
    .创建符号及附加声明(符号标志_.属性_, "offset"d, offset, 结构体成员, K.获取内置类型(内置类型_.正整数64类型));
    // ti: %object.TypeInfo*,
    属性声明_ ti = fc.创建属性声明(fc.创建标识符("ti"d), fc.创建指针类型(TIC));
    .创建符号及附加声明(符号标志_.属性_, "ti"d, ti, 结构体成员, K.创建指针类型(.获取合成节点扩展(TIC).解析类型));
    结构声明节点_ 结构声明 = fc.创建结构声明(fc.创建文本标识符(名称), ·to!(节点数组_!(节点_))(fc.f·创建节点数组!(属性声明_)([offset, ti], false)));
    if (符号 is ··null!(符号_)) {
        符号 = .创建符号及附加声明(符号标志_.结构_, 名称, 结构声明, 符号表);
    }
    else {
        assert((符号.标志 & 符号标志_.符号占位符_) != 0, "错误了"c);
        .设置符号关系(符号, 结构声明, 符号表);
    }
    return .设置声明类型(符号, 结构体成员);
}
符号_ COB_ModuleInfo(符号表_ 符号表) {
    dstring 名称 = "object.ModuleInfo"d;
    /**
        结构 "object.ModuleInfo" {
            _flags: i32
            _index: i32,
        }
    */
    符号_ 符号;
    if (符号表.具有(名称)) {
        符号 = (cast(符号_)(符号表.获取(名称)));
        if ((符号.标志 & 符号标志_.符号占位符_) == 0) {
            return 符号;
        }
    }
    符号表_ 结构体成员 = 创建符号表();
    // _flags: i32, 
    属性声明_ _flags = fc.创建属性声明(fc.创建标识符("_flags"d), fc.创建关键字类型节点(KSK.正整数32_));
    .创建符号及附加声明(符号标志_.属性_, "_flags"d, _flags, 结构体成员, K.获取内置类型(内置类型_.正整数32类型));
    // _index: i32, 
    属性声明_ _index = fc.创建属性声明(fc.创建标识符("_index"d), fc.创建关键字类型节点(KSK.正整数32_));
    .创建符号及附加声明(符号标志_.属性_, "_index"d, _index, 结构体成员, K.获取内置类型(内置类型_.正整数32类型));
    结构声明节点_ 结构声明 = fc.创建结构声明(fc.创建文本标识符(名称), ·to!(节点数组_!(节点_))(fc.f·创建节点数组!(属性声明_)([_flags, _index], false)));
    if (符号 is ··null!(符号_)) {
        符号 = .创建符号及附加声明(符号标志_.结构_, 名称, 结构声明, 符号表);
    }
    else {
        assert((符号.标志 & 符号标志_.符号占位符_) != 0, "错误了"c);
        .设置符号关系(符号, 结构声明, 符号表);
    }
    return .设置声明类型(符号, 结构体成员);
}
符号_ COB_TypeInfo_Tuple(符号表_ 符号表) {
    // TypeInfo[] elements;
    dstring 名称 = "object.TypeInfo_Tuple"d;
    符号_ 符号;
    if (符号表.具有(名称)) {
        符号 = (cast(符号_)(符号表.获取(名称)));
        if ((符号.标志 & 符号标志_.符号占位符_) == 0) {
            return 符号;
        }
    }
    符号表_ 结构体成员 = 创建符号表();
    // __vptr : [19 x i8*]*, 
    属性声明_ __vptr = fc.创建属性声明(fc.创建标识符("__vptr"d), fc.创建指针类型(fc.创建数组类型(fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)), fc.创建字面量类型(fc.创建数字字面量(19, 节点标志_.无)))));
    .创建符号及附加声明(符号标志_.属性_, "__vptr"d, __vptr, 结构体成员, K.创建指针类型(K.创建数组类型(K.获取内置类型(内置类型_.无值指针类型), K.创建正整数字面量类型(类型标志_.正整数64_, 19))));
    // __monitor: i8*,
    属性声明_ __monitor = fc.创建属性声明(fc.创建标识符("__monitor"d), fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)));
    .创建符号及附加声明(符号标志_.属性_, "__monitor"d, __monitor, 结构体成员, K.获取内置类型(内置类型_.无值指针类型));
    类型引用_ TIC = fc.创建类型引用(fc.创建起始限定名(fc.创建文本标识符("object.TypeInfo"d)));
    符号_ TICS = .获取类型引用符号或占位符(符号表, "object.TypeInfo"d, TIC);
    if (TICS is ··null!(符号_)) {
        类型_ 声明类型 = K.创建站位结构类型();
        .创建类型引用符号占位符(符号表, 符号标志_.结构_, "object.TypeInfo"d, TIC, 声明类型);
    }
    // elements: %object.TypeInfo[],
    属性声明_ elements = fc.创建属性声明(fc.创建标识符("elements"d), fc.创建动态数组类型(TIC));
    .创建符号及附加声明(符号标志_.属性_, "elements"d, elements, 结构体成员, K.创建动态数组类型(.获取合成节点扩展(TIC).解析类型));
    对象声明_ 对象声明 = fc.创建对象声明(fc.创建文本标识符(名称), ·to!(节点数组_!(节点_))(fc.f·创建节点数组!(属性声明_)([__vptr, __monitor, elements], false)));
    if (符号 is ··null!(符号_)) {
        符号 = .创建符号及附加声明(符号标志_.对象_, 名称, 对象声明, 符号表);
    }
    else {
        assert((符号.标志 & 符号标志_.符号占位符_) != 0, "错误了"c);
        .设置符号关系(符号, 对象声明, 符号表);
    }
    return .设置声明类型(符号, 结构体成员);
}
符号_ COB_TypeInfo_X(符号表_ 符号表, dstring 名称) {
    符号_ 符号;
    if (符号表.具有(名称)) {
        符号 = (cast(符号_)(符号表.获取(名称)));
        if ((符号.标志 & 符号标志_.符号占位符_) == 0) {
            return 符号;
        }
    }
    符号表_ 结构体成员 = 创建符号表();
    // __vptr : [19 x i8*]*, 
    属性声明_ __vptr = fc.创建属性声明(fc.创建标识符("__vptr"d), fc.创建指针类型(fc.创建数组类型(fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)), fc.创建字面量类型(fc.创建数字字面量(19, 节点标志_.无)))));
    .创建符号及附加声明(符号标志_.属性_, "__vptr"d, __vptr, 结构体成员, K.创建指针类型(K.创建数组类型(K.获取内置类型(内置类型_.无值指针类型), K.创建正整数字面量类型(类型标志_.正整数64_, 19))));
    // __monitor: i8*,
    属性声明_ __monitor = fc.创建属性声明(fc.创建标识符("__monitor"d), fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)));
    .创建符号及附加声明(符号标志_.属性_, "__monitor"d, __monitor, 结构体成员, K.获取内置类型(内置类型_.无值指针类型));
    类型引用_ TIC = fc.创建类型引用(fc.创建起始限定名(fc.创建文本标识符("object.TypeInfo"d)));
    符号_ TICS = .获取类型引用符号或占位符(符号表, "object.TypeInfo"d, TIC);
    if (TICS is ··null!(符号_)) {
        类型_ 声明类型 = K.创建站位结构类型();
        .创建类型引用符号占位符(符号表, 符号标志_.结构_, "object.TypeInfo"d, TIC, 声明类型);
    }
    // base: %object.TypeInfo*,
    属性声明_ base = fc.创建属性声明(fc.创建标识符("base"d), fc.创建指针类型(TIC));
    .创建符号及附加声明(符号标志_.属性_, "base"d, base, 结构体成员, K.创建指针类型(.获取合成节点扩展(TIC).解析类型));
    对象声明_ 对象声明 = fc.创建对象声明(fc.创建文本标识符(名称), ·to!(节点数组_!(节点_))(fc.f·创建节点数组!(属性声明_)([__vptr, __monitor, base], false)));
    if (符号 is ··null!(符号_)) {
        符号 = .创建符号及附加声明(符号标志_.对象_, 名称, 对象声明, 符号表);
    }
    else {
        assert((符号.标志 & 符号标志_.符号占位符_) != 0, "错误了"c);
        .设置符号关系(符号, 对象声明, 符号表);
    }
    return .设置声明类型(符号, 结构体成员);
}
符号_ COB_TypeInfo_Const(符号表_ 符号表) {
    return .COB_TypeInfo_X(符号表, "object.TypeInfo_Const"d);
}
符号_ COB_TypeInfo_Invariant(符号表_ 符号表) {
    return .COB_TypeInfo_X(符号表, "object.TypeInfo_Invariant"d);
}
符号_ COB_TypeInfo_Shared(符号表_ 符号表) {
    return .COB_TypeInfo_X(符号表, "object.TypeInfo_Shared"d);
}
符号_ COB_TypeInfo_F(符号表_ 符号表, dstring 名称) {
    符号_ 符号;
    if (符号表.具有(名称)) {
        符号 = (cast(符号_)(符号表.获取(名称)));
        if ((符号.标志 & 符号标志_.符号占位符_) == 0) {
            return 符号;
        }
    }
    符号表_ 结构体成员 = 创建符号表();
    // __vptr : [19 x i8*]*, 
    属性声明_ __vptr = fc.创建属性声明(fc.创建标识符("__vptr"d), fc.创建指针类型(fc.创建数组类型(fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)), fc.创建字面量类型(fc.创建数字字面量(19, 节点标志_.无)))));
    .创建符号及附加声明(符号标志_.属性_, "__vptr"d, __vptr, 结构体成员, K.创建指针类型(K.创建数组类型(K.获取内置类型(内置类型_.无值指针类型), K.创建正整数字面量类型(类型标志_.正整数64_, 19))));
    // __monitor: i8*,
    属性声明_ __monitor = fc.创建属性声明(fc.创建标识符("__monitor"d), fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)));
    .创建符号及附加声明(符号标志_.属性_, "__monitor"d, __monitor, 结构体成员, K.获取内置类型(内置类型_.无值指针类型));
    类型引用_ TIC = fc.创建类型引用(fc.创建起始限定名(fc.创建文本标识符("object.TypeInfo"d)));
    符号_ TICS = .获取类型引用符号或占位符(符号表, "object.TypeInfo"d, TIC);
    if (TICS is ··null!(符号_)) {
        类型_ 声明类型 = K.创建站位结构类型();
        .创建类型引用符号占位符(符号表, 符号标志_.结构_, "object.TypeInfo"d, TIC, 声明类型);
    }
    // next: %object.TypeInfo*,
    属性声明_ next = fc.创建属性声明(fc.创建标识符("next"d), fc.创建指针类型(TIC));
    .创建符号及附加声明(符号标志_.属性_, "next"d, next, 结构体成员, K.创建指针类型(.获取合成节点扩展(TIC).解析类型));
    // deco: { i64, i8* }, 
    属性声明_ deco = fc.创建属性声明(fc.创建标识符("deco"d), fc.创建动态数组类型(fc.创建关键字类型节点(KSK.字符8_)));
    .创建符号及附加声明(符号标志_.属性_, "deco"d, deco, 结构体成员, K.创建动态数组类型(K.获取内置类型(内置类型_.字符8类型)));
    对象声明_ 对象声明 = fc.创建对象声明(fc.创建文本标识符(名称), ·to!(节点数组_!(节点_))(fc.f·创建节点数组!(属性声明_)([__vptr, __monitor, next, deco], false)));
    if (符号 is ··null!(符号_)) {
        符号 = .创建符号及附加声明(符号标志_.对象_, 名称, 对象声明, 符号表);
    }
    else {
        assert((符号.标志 & 符号标志_.符号占位符_) != 0, "错误了"c);
        .设置符号关系(符号, 对象声明, 符号表);
    }
    return .设置声明类型(符号, 结构体成员);
}
符号_ COB_TypeInfo_Delegate(符号表_ 符号表) {
    // TypeInfo next; 
    // string deco;
    return .COB_TypeInfo_F(符号表, "object.TypeInfo_Delegate"d);
}
符号_ COB_TypeInfo_Function(符号表_ 符号表) {
    // TypeInfo next; 
    // string deco;
    return .COB_TypeInfo_F(符号表, "object.TypeInfo_Function"d);
}
符号_ COB_TypeInfo_V(符号表_ 符号表, dstring 名称) {
    符号_ 符号;
    if (符号表.具有(名称)) {
        符号 = (cast(符号_)(符号表.获取(名称)));
        if ((符号.标志 & 符号标志_.符号占位符_) == 0) {
            return 符号;
        }
    }
    符号表_ 结构体成员 = 创建符号表();
    // __vptr : [19 x i8*]*, 
    属性声明_ __vptr = fc.创建属性声明(fc.创建标识符("__vptr"d), fc.创建指针类型(fc.创建数组类型(fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)), fc.创建字面量类型(fc.创建数字字面量(19, 节点标志_.无)))));
    .创建符号及附加声明(符号标志_.属性_, "__vptr"d, __vptr, 结构体成员, K.创建指针类型(K.创建数组类型(K.获取内置类型(内置类型_.无值指针类型), K.创建正整数字面量类型(类型标志_.正整数64_, 19))));
    // __monitor: i8*,
    属性声明_ __monitor = fc.创建属性声明(fc.创建标识符("__monitor"d), fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)));
    .创建符号及附加声明(符号标志_.属性_, "__monitor"d, __monitor, 结构体成员, K.获取内置类型(内置类型_.无值指针类型));
    类型引用_ TIC = fc.创建类型引用(fc.创建起始限定名(fc.创建文本标识符("object.TypeInfo"d)));
    符号_ TICS = .获取类型引用符号或占位符(符号表, "object.TypeInfo"d, TIC);
    if (TICS is ··null!(符号_)) {
        类型_ 声明类型 = K.创建站位结构类型();
        .创建类型引用符号占位符(符号表, 符号标志_.结构_, "object.TypeInfo"d, TIC, 声明类型);
    }
    // value: %object.TypeInfo*,
    属性声明_ value = fc.创建属性声明(fc.创建标识符("value"d), fc.创建指针类型(TIC));
    .创建符号及附加声明(符号标志_.属性_, "value"d, value, 结构体成员, K.创建指针类型(.获取合成节点扩展(TIC).解析类型));
    对象声明_ 对象声明 = fc.创建对象声明(fc.创建文本标识符(名称), ·to!(节点数组_!(节点_))(fc.f·创建节点数组!(属性声明_)([__vptr, __monitor, value], false)));
    if (符号 is ··null!(符号_)) {
        符号 = .创建符号及附加声明(符号标志_.对象_, 名称, 对象声明, 符号表);
    }
    else {
        assert((符号.标志 & 符号标志_.符号占位符_) != 0, "错误了"c);
        .设置符号关系(符号, 对象声明, 符号表);
    }
    return .设置声明类型(符号, 结构体成员);
}
符号_ COB_TypeInfo_AssociativeArray(符号表_ 符号表) {
    // TypeInfo value;
    // TypeInfo key;
    dstring 名称 = "object.TypeInfo_AssociativeArray"d;
    符号_ 符号;
    if (符号表.具有(名称)) {
        符号 = (cast(符号_)(符号表.获取(名称)));
        if ((符号.标志 & 符号标志_.符号占位符_) == 0) {
            return 符号;
        }
    }
    符号表_ 结构体成员 = 创建符号表();
    // __vptr : [19 x i8*]*, 
    属性声明_ __vptr = fc.创建属性声明(fc.创建标识符("__vptr"d), fc.创建指针类型(fc.创建数组类型(fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)), fc.创建字面量类型(fc.创建数字字面量(19, 节点标志_.无)))));
    .创建符号及附加声明(符号标志_.属性_, "__vptr"d, __vptr, 结构体成员, K.创建指针类型(K.创建数组类型(K.获取内置类型(内置类型_.无值指针类型), K.创建正整数字面量类型(类型标志_.正整数64_, 19))));
    // __monitor: i8*,
    属性声明_ __monitor = fc.创建属性声明(fc.创建标识符("__monitor"d), fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)));
    .创建符号及附加声明(符号标志_.属性_, "__monitor"d, __monitor, 结构体成员, K.获取内置类型(内置类型_.无值指针类型));
    类型引用_ TIC = fc.创建类型引用(fc.创建起始限定名(fc.创建文本标识符("object.TypeInfo"d)));
    符号_ TICS = .获取类型引用符号或占位符(符号表, "object.TypeInfo"d, TIC);
    if (TICS is ··null!(符号_)) {
        类型_ 声明类型 = K.创建站位结构类型();
        .创建类型引用符号占位符(符号表, 符号标志_.结构_, "object.TypeInfo"d, TIC, 声明类型);
    }
    // value: %object.TypeInfo*,
    属性声明_ value = fc.创建属性声明(fc.创建标识符("value"d), fc.创建指针类型(TIC));
    .创建符号及附加声明(符号标志_.属性_, "value"d, value, 结构体成员, K.创建指针类型(.获取合成节点扩展(TIC).解析类型));
    // key: %object.TypeInfo*,
    属性声明_ key = fc.创建属性声明(fc.创建标识符("key"d), fc.创建指针类型(TIC));
    .创建符号及附加声明(符号标志_.属性_, "key"d, key, 结构体成员, K.创建指针类型(.获取合成节点扩展(TIC).解析类型));
    对象声明_ 对象声明 = fc.创建对象声明(fc.创建文本标识符(名称), ·to!(节点数组_!(节点_))(fc.f·创建节点数组!(属性声明_)([__vptr, __monitor, value, key], false)));
    if (符号 is ··null!(符号_)) {
        符号 = .创建符号及附加声明(符号标志_.对象_, 名称, 对象声明, 符号表);
    }
    else {
        assert((符号.标志 & 符号标志_.符号占位符_) != 0, "错误了"c);
        .设置符号关系(符号, 对象声明, 符号表);
    }
    return .设置声明类型(符号, 结构体成员);
}
符号_ COB_TypeInfo_StaticArray(符号表_ 符号表) {
    // TypeInfo value; 
    // size_t   len;
    dstring 名称 = "object.TypeInfo_StaticArray"d;
    符号_ 符号;
    if (符号表.具有(名称)) {
        符号 = (cast(符号_)(符号表.获取(名称)));
        if ((符号.标志 & 符号标志_.符号占位符_) == 0) {
            return 符号;
        }
    }
    符号表_ 结构体成员 = 创建符号表();
    // __vptr : [19 x i8*]*, 
    属性声明_ __vptr = fc.创建属性声明(fc.创建标识符("__vptr"d), fc.创建指针类型(fc.创建数组类型(fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)), fc.创建字面量类型(fc.创建数字字面量(19, 节点标志_.无)))));
    .创建符号及附加声明(符号标志_.属性_, "__vptr"d, __vptr, 结构体成员, K.创建指针类型(K.创建数组类型(K.获取内置类型(内置类型_.无值指针类型), K.创建正整数字面量类型(类型标志_.正整数64_, 19))));
    // __monitor: i8*,
    属性声明_ __monitor = fc.创建属性声明(fc.创建标识符("__monitor"d), fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)));
    .创建符号及附加声明(符号标志_.属性_, "__monitor"d, __monitor, 结构体成员, K.获取内置类型(内置类型_.无值指针类型));
    类型引用_ TIC = fc.创建类型引用(fc.创建起始限定名(fc.创建文本标识符("object.TypeInfo"d)));
    符号_ TICS = .获取类型引用符号或占位符(符号表, "object.TypeInfo"d, TIC);
    if (TICS is ··null!(符号_)) {
        类型_ 声明类型 = K.创建站位结构类型();
        .创建类型引用符号占位符(符号表, 符号标志_.结构_, "object.TypeInfo"d, TIC, 声明类型);
    }
    // value: %object.TypeInfo*,
    属性声明_ value = fc.创建属性声明(fc.创建标识符("value"d), fc.创建指针类型(TIC));
    .创建符号及附加声明(符号标志_.属性_, "value"d, value, 结构体成员, K.创建指针类型(.获取合成节点扩展(TIC).解析类型));
    // len: i64, 
    属性声明_ len = fc.创建属性声明(fc.创建标识符("len"d), fc.创建关键字类型节点(KSK.正整数64_));
    .创建符号及附加声明(符号标志_.属性_, "len"d, len, 结构体成员, K.获取内置类型(内置类型_.正整数64类型));
    对象声明_ 对象声明 = fc.创建对象声明(fc.创建文本标识符(名称), ·to!(节点数组_!(节点_))(fc.f·创建节点数组!(属性声明_)([__vptr, __monitor, value, len], false)));
    if (符号 is ··null!(符号_)) {
        符号 = .创建符号及附加声明(符号标志_.对象_, 名称, 对象声明, 符号表);
    }
    else {
        assert((符号.标志 & 符号标志_.符号占位符_) != 0, "错误了"c);
        .设置符号关系(符号, 对象声明, 符号表);
    }
    return .设置声明类型(符号, 结构体成员);
}
符号_ COB_TypeInfo_Array(符号表_ 符号表) {
    // TypeInfo value; 
    return .COB_TypeInfo_V(符号表, "object.TypeInfo_Array"d);
}
符号_ COB_TypeInfo_Pointer(符号表_ 符号表) {
    // TypeInfo value;
    return .COB_TypeInfo_V(符号表, "object.TypeInfo_Pointer"d);
}
符号_ COB_TypeInfo_Enum(符号表_ 符号表) {
    // TypeInfo base;
    // string   name;
    // void[]   m_init;
    dstring 名称 = "object.TypeInfo_Enum"d;
    符号_ 符号;
    if (符号表.具有(名称)) {
        符号 = (cast(符号_)(符号表.获取(名称)));
        if ((符号.标志 & 符号标志_.符号占位符_) == 0) {
            return 符号;
        }
    }
    符号表_ 结构体成员 = 创建符号表();
    // __vptr : [19 x i8*]*, 
    属性声明_ __vptr = fc.创建属性声明(fc.创建标识符("__vptr"d), fc.创建指针类型(fc.创建数组类型(fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)), fc.创建字面量类型(fc.创建数字字面量(19, 节点标志_.无)))));
    .创建符号及附加声明(符号标志_.属性_, "__vptr"d, __vptr, 结构体成员, K.创建指针类型(K.创建数组类型(K.获取内置类型(内置类型_.无值指针类型), K.创建正整数字面量类型(类型标志_.正整数64_, 19))));
    // __monitor: i8*,
    属性声明_ __monitor = fc.创建属性声明(fc.创建标识符("__monitor"d), fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)));
    .创建符号及附加声明(符号标志_.属性_, "__monitor"d, __monitor, 结构体成员, K.获取内置类型(内置类型_.无值指针类型));
    类型引用_ TIC = fc.创建类型引用(fc.创建起始限定名(fc.创建文本标识符("object.TypeInfo"d)));
    符号_ TICS = .获取类型引用符号或占位符(符号表, "object.TypeInfo"d, TIC);
    if (TICS is ··null!(符号_)) {
        类型_ 声明类型 = K.创建站位结构类型();
        .创建类型引用符号占位符(符号表, 符号标志_.结构_, "object.TypeInfo"d, TIC, 声明类型);
    }
    // base: %object.TypeInfo*,
    属性声明_ base = fc.创建属性声明(fc.创建标识符("base"d), fc.创建指针类型(TIC));
    .创建符号及附加声明(符号标志_.属性_, "base"d, base, 结构体成员, K.创建指针类型(.获取合成节点扩展(TIC).解析类型));
    // name: { i64, i8* }, 
    属性声明_ name = fc.创建属性声明(fc.创建标识符("name"d), fc.创建动态数组类型(fc.创建关键字类型节点(KSK.字符8_)));
    .创建符号及附加声明(符号标志_.属性_, "name"d, name, 结构体成员, K.创建动态数组类型(K.获取内置类型(内置类型_.字符8类型)));
    // m_init: void[];
    属性声明_ m_init = fc.创建属性声明(fc.创建标识符("m_init"d), fc.创建动态数组类型(fc.创建关键字类型节点(KSK.无值_)));
    .创建符号及附加声明(符号标志_.属性_, "m_init"d, m_init, 结构体成员, K.创建动态数组类型(K.获取内置类型(内置类型_.无值类型)));
    对象声明_ 对象声明 = fc.创建对象声明(fc.创建文本标识符(名称), ·to!(节点数组_!(节点_))(fc.f·创建节点数组!(属性声明_)([__vptr, __monitor, base, name, m_init], false)));
    if (符号 is ··null!(符号_)) {
        符号 = .创建符号及附加声明(符号标志_.对象_, 名称, 对象声明, 符号表);
    }
    else {
        assert((符号.标志 & 符号标志_.符号占位符_) != 0, "错误了"c);
        .设置符号关系(符号, 对象声明, 符号表);
    }
    return .设置声明类型(符号, 结构体成员);
}
符号_ COB_Object(符号表_ 符号表) {
    dstring 名称 = "object.Object"d;
    符号_ 符号;
    if (符号表.具有(名称)) {
        符号 = (cast(符号_)(符号表.获取(名称)));
        if ((符号.标志 & 符号标志_.符号占位符_) == 0) {
            return 符号;
        }
    }
    符号表_ 结构体成员 = 创建符号表();
    属性声明_ __vptr = fc.创建属性声明(fc.创建标识符("__vptr"d), fc.创建指针类型(fc.创建数组类型(fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)), fc.创建字面量类型(fc.创建数字字面量(5, 节点标志_.无)))));
    .创建符号及附加声明(符号标志_.属性_, "__vptr"d, __vptr, 结构体成员, K.创建指针类型(K.创建数组类型(K.获取内置类型(内置类型_.无值指针类型), K.创建正整数字面量类型(类型标志_.正整数64_, 5))));
    属性声明_ __monitor = fc.创建属性声明(fc.创建标识符("__monitor"d), fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)));
    .创建符号及附加声明(符号标志_.属性_, "__monitor"d, __monitor, 结构体成员, K.获取内置类型(内置类型_.无值指针类型));
    对象声明_ 对象声明 = fc.创建对象声明(fc.创建文本标识符(名称), ·to!(节点数组_!(节点_))(fc.f·创建节点数组!(属性声明_)([__vptr, __monitor], false)));
    if (符号 is ··null!(符号_)) {
        符号 = .创建符号及附加声明(符号标志_.对象_, 名称, 对象声明, 符号表);
    }
    else {
        assert((符号.标志 & 符号标志_.符号占位符_) != 0, "错误了"c);
        .设置符号关系(符号, 对象声明, 符号表);
    }
    return .设置声明类型(符号, 结构体成员);
}
符号_ COB_TypeInfo_vtblZ(符号表_ 符号表, dstring 名称, long 虚表长度) {
    符号_ 符号;
    if (符号表.具有(名称)) {
        符号 = (cast(符号_)(符号表.获取(名称)));
        if ((符号.标志 & 符号标志_.符号占位符_) == 0) {
            return 符号;
        }
    }
    数组类型节点_ PT = fc.创建数组类型(fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_)), fc.创建字面量类型(fc.创建数字字面量(虚表长度, 节点标志_.无)));
    修饰符_ 修饰符 = (cast(修饰符_)(fc.转为令牌(KSK.声明_)));
    变量声明_ VarDec = .创建全局变量声明(fc.创建文本标识符(名称), PT, [修饰符], 节点标志_.Const);
    if (符号 is ··null!(符号_)) {
        符号 = .创建符号及附加声明(符号标志_.全局变量_, 名称, VarDec, 符号表, K.创建指针类型(K.创建数组类型(K.获取内置类型(内置类型_.无值指针类型), K.创建正整数字面量类型(类型标志_.正整数64_, 虚表长度))));
    }
    else {
        assert((符号.标志 & 符号标志_.符号占位符_) != 0, "错误了"c);
        .设置符号关系(符号, VarDec, 符号表);
    }
    符号.标志 |= (cast(整数_)(符号标志_.声明_));
    return 符号;
}
符号_ COB_D15TypeInfo_Struct6__vtblZ(符号表_ 符号表) {
    return .COB_TypeInfo_vtblZ(符号表, "_D15TypeInfo_Struct6__vtblZ"d, 19);
}
符号_ COB_D18TypeInfo_Invariant6__vtblZ(符号表_ 符号表) {
    return .COB_TypeInfo_vtblZ(符号表, "_D18TypeInfo_Invariant6__vtblZ"d, 19);
}
符号_ COB_D14TypeInfo_Const6__vtblZ(符号表_ 符号表) {
    return .COB_TypeInfo_vtblZ(符号表, "_D14TypeInfo_Const6__vtblZ"d, 19);
}
符号_ COB_D15TypeInfo_Shared6__vtblZ(符号表_ 符号表) {
    return .COB_TypeInfo_vtblZ(符号表, "_D15TypeInfo_Shared6__vtblZ"d, 19);
}
符号_ COB_D14TypeInfo_Class6__vtblZ(符号表_ 符号表) {
    return .COB_TypeInfo_vtblZ(符号表, "_D14TypeInfo_Class6__vtblZ"d, 22);
}
符号_ COB_D14TypeInfo_Tuple6__vtblZ(符号表_ 符号表) {
    return .COB_TypeInfo_vtblZ(符号表, "_D14TypeInfo_Tuple6__vtblZ"d, 19);
}
符号_ COB_D17TypeInfo_Delegate6__vtblZ(符号表_ 符号表) {
    return .COB_TypeInfo_vtblZ(符号表, "_D17TypeInfo_Delegate6__vtblZ"d, 19);
}
符号_ COB_D17TypeInfo_Function6__vtblZ(符号表_ 符号表) {
    return .COB_TypeInfo_vtblZ(符号表, "_D17TypeInfo_Function6__vtblZ"d, 19);
}
// _D25TypeInfo_AssociativeArray6__vtblZ
符号_ COB_D25TypeInfo_AssociativeArray6__vtblZ(符号表_ 符号表) {
    return .COB_TypeInfo_vtblZ(符号表, "_D25TypeInfo_AssociativeArray6__vtblZ"d, 19);
}
// _D20TypeInfo_StaticArray6__vtblZ
符号_ COB_D20TypeInfo_StaticArray6__vtblZ(符号表_ 符号表) {
    return .COB_TypeInfo_vtblZ(符号表, "_D20TypeInfo_StaticArray6__vtblZ"d, 19);
}
// _D14TypeInfo_Array6__vtblZ
符号_ COB_D14TypeInfo_Array6__vtblZ(符号表_ 符号表) {
    return .COB_TypeInfo_vtblZ(符号表, "_D14TypeInfo_Array6__vtblZ"d, 19);
}
// _D16TypeInfo_Pointer6__vtblZ
符号_ COB_D16TypeInfo_Pointer6__vtblZ(符号表_ 符号表) {
    return .COB_TypeInfo_vtblZ(符号表, "_D16TypeInfo_Pointer6__vtblZ"d, 19);
}
// _D13TypeInfo_Enum6__vtblZ
符号_ COB_D13TypeInfo_Enum6__vtblZ(符号表_ 符号表) {
    return .COB_TypeInfo_vtblZ(符号表, "_D13TypeInfo_Enum6__vtblZ"d, 19);
}
// _D6Object7__ClassZ
符号_ COB_D6Object7__ClassZ(符号表_ 符号表) {
    dstring 名称 = "_D6Object7__ClassZ"d;
    符号_ 符号;
    if (符号表.具有(名称)) {
        符号 = (cast(符号_)(符号表.获取(名称)));
        if ((符号.标志 & 符号标志_.符号占位符_) == 0) {
            return 符号;
        }
    }
    类型引用_ TIC = fc.创建类型引用(fc.创建起始限定名(fc.创建文本标识符("object.TypeInfo_Class"d)));
    符号_ TICS = .获取类型引用符号或占位符(符号表, "object.TypeInfo_Class"d, TIC);
    if (TICS is ··null!(符号_)) {
        类型_ 声明类型 = K.创建站位结构类型();
        .创建类型引用符号占位符(符号表, 符号标志_.结构_, "object.TypeInfo_Class"d, TIC, 声明类型);
    }
    修饰符_ 修饰符 = (cast(修饰符_)(fc.转为令牌(KSK.声明_)));
    变量声明_ VarDec = .创建全局变量声明(fc.创建文本标识符(名称), TIC, [修饰符], 节点标志_.Let);
    if (符号 is ··null!(符号_)) {
        符号 = .创建符号及附加声明(符号标志_.全局变量_, 名称, VarDec, 符号表, .获取合成节点扩展(TIC).解析类型);
    }
    else {
        assert((符号.标志 & 符号标志_.符号占位符_) != 0, "错误了"c);
        .设置符号关系(符号, VarDec, 符号表);
    }
    符号.标志 |= (cast(整数_)(符号标志_.声明_));
    return 符号;
}
符号_ 获取符号引用符号或占位符(符号表_ 符号表, dstring 名称, 节点_ 引用节点) {
    节点扩展_ 扩展 = new 节点扩展_(引用节点, 节点检查标志_.无_);
    if (符号表.具有(名称)) {
        符号_ S = (cast(符号_)(符号表.获取(名称)));
        扩展.解析符号 = S;
        引用节点.扩展 = (cast(void*)(扩展));
        return S;
    }
    return ··null!(符号_);
}
符号_ 创建符号引用符号占位符(符号表_ 符号表, 符号标志_ 符号标志, dstring 名称, 节点_ 引用节点, 类型_ 类型 = ··null!(类型_)) {
    节点扩展_ 扩展 = new 节点扩展_(引用节点, 节点检查标志_.无_);
    符号_ S = new 符号_((cast(整数_)(符号标志 | 符号标志_.符号占位符_)), 名称);
    if (类型 !is ··null!(类型_)) {
        扩展.解析类型 = 类型;
        S.类型 = 类型;
    }
    引用节点.扩展 = (cast(void*)(扩展));
    符号表.p·设置(名称, S);
    return S;
}
符号_ 获取类型引用符号或占位符(符号表_ 符号表, dstring 名称, 节点_ 引用节点) {
    节点扩展_ 扩展 = new 节点扩展_(引用节点, 节点检查标志_.无_);
    if (符号表.具有(名称)) {
        符号_ S = (cast(符号_)(符号表.获取(名称)));
        扩展.解析类型 = S.声明类型 ? S.声明类型 : S.类型;
        引用节点.扩展 = (cast(void*)(扩展));
        return S;
    }
    return ··null!(符号_);
}
符号_ 创建类型引用符号占位符(符号表_ 符号表, 符号标志_ 符号标志, dstring 名称, 节点_ 引用节点, 类型_ 声明类型 = ··null!(类型_), 类型_ 类型 = ··null!(类型_)) {
    节点扩展_ 扩展 = new 节点扩展_(引用节点, 节点检查标志_.无_);
    符号_ S = new 符号_((cast(整数_)(符号标志 | 符号标志_.符号占位符_)), 名称);
    if (声明类型 !is ··null!(类型_)) {
        if (声明类型.符号 is ··null!(基础符号_)) {
            声明类型.符号 = S;
        }
        扩展.解析类型 = 声明类型;
        S.声明类型 = 声明类型;
    }
    if (类型 !is ··null!(类型_)) {
        扩展.解析类型 = 类型;
        S.类型 = 类型;
    }
    引用节点.扩展 = (cast(void*)(扩展));
    符号表.p·设置(名称, S);
    return S;
}
符号_ 创建函数类型节点(形参声明_[] 形参组, 节点_ 返回类型) {
    ··Klang节点_.括号类型_ FT = fc.创建括号类型(fc.创建函数类型(fc.f·创建节点数组!(形参声明_)(形参组, false), 返回类型));
    符号_ FS = .创建符号(符号标志_.签名_, 内部符号名_.调用_);
    FT.符号 = FS;
    FS.值声明 = FT;
    FS.声明组 = cast(基础节点_[])(创建数组!(节点_)());
    .追加!(基础节点_)(FS.声明组, FT);
    符号_ FST = .创建符号(符号标志_.类型字面量_, 内部符号名_.类型_);
    FST.值声明 = FT;
    FST.声明组 = cast(基础节点_[])(创建数组!(节点_)());
    .追加!(基础节点_)(FST.声明组, FT);
    FST.成员 = 创建符号表();
    FST.成员.p·设置(内部符号名_.调用_, FS);
    类型_ FTT = K.创建函数类型(FS);
    FS.类型 = FTT;
    FS.声明类型 = FTT;
    return FS;
}
符号_ 创建符号及附加声明(符号标志_ 符号标志, dstring 名称, 基础节点_ 声明节点, 符号表_ 符号表, 类型_ 类型 = ··null!(类型_), 类型_ 声明类型 = ··null!(类型_)) {
    符号_ S = new 符号_((cast(整数_)(符号标志)), 名称);
    符号表.p·设置(名称, S);
    return .设置符号关系(S, 声明节点, 符号表, 类型, 声明类型);
}
符号_ 创建符号(符号标志_ 标志, dstring 名称) {
    return new 符号_((cast(整数_)(标志)), 名称);
}
符号_ 设置符号关系(符号_ 符号, 基础节点_ 声明节点, 符号表_ 符号表, 类型_ 类型 = ··null!(类型_), 类型_ 声明类型 = ··null!(类型_)) {
    assert(符号表.具有(符号.名称), "错误2"c);
    符号.标志 &= (cast(整数_)(~符号标志_.符号占位符_));
    符号.值声明 = 声明节点;
    符号.声明组 = 创建数组!(基础节点_)();
    .追加!(基础节点_)(符号.声明组, 声明节点);
    声明节点.符号 = 符号;
    if (类型 !is ··null!(类型_)) {
        符号.类型 = 类型;
    }
    if (声明类型 !is ··null!(类型_)) {
        声明类型.符号 = 符号;
        符号.声明类型 = 声明类型;
    }
    return 符号;
}
符号_ 设置声明类型(符号_ 符号, 符号表_ 成员组) {
    符号.成员 = 成员组;
    类型_ 符号声明类型 = K.创建结构类型(符号);
    符号声明类型.成员已解析 = true;
    符号声明类型.属性组 = 成员组;
    符号.声明类型 = 符号声明类型;
    return 符号;
}
变量声明_ 创建全局变量声明(标识符_ 名称, 节点_ PT, 修饰符_[] 修饰符, 节点标志_ 标志) {
    变量声明_ VarDec = fc.创建变量声明(名称, PT);
    ··Klang节点_.变量声明列表_ VL = fc.创建变量声明列表(fc.f·创建节点数组!(变量声明_)([VarDec], false));
    VL.标志 |= (cast(整数_)(标志));
    VarDec.父节点 = VL;
    ··Klang节点_.变量语句_ VS = fc.创建变量声明语句(VL, fc.f·创建节点数组!(修饰符_)(new 节点数组_!(修饰符_)(修饰符)));
    VL.父节点 = VS;
    return VarDec;
}
dstring 碎裂(节点_ n) {
    return "符号名称_"d;
}
节点扩展_ 获取合成节点扩展(基础节点_ 节点) {
    if (节点.扩展 is ··null!(void*)) {
        节点.扩展 = (cast(void*)(new 节点扩展_(节点, 节点检查标志_.无_)));
    }
    return (cast(节点扩展_)(节点.扩展));
}
节点_ 实例化类型(类型_ type) {
    if (type is ··null!(类型_)) {
        return 返回零值!(节点_)();
    }
    if ((type.标志 & 类型标志_.排除集类型_) != 0) {
        type = type.类型;
    }
    if ((type.标志 & 类型标志_.限定类型_) != 0) {
        节点_ 新节点;
        if ((type.复合标志 & 复合标志_.只读_) != 0) {
            新节点 = fc.创建类型限定类型(KSK.只读_, fc.创建括号类型(.实例化类型(type.类型)));
        }
        else if ((type.复合标志 & 复合标志_.恒定_) != 0) {
            新节点 = fc.创建类型限定类型(KSK.恒定_, fc.创建括号类型(.实例化类型(type.类型)));
        }
        else if ((type.复合标志 & 复合标志_.共享_) != 0) {
            新节点 = fc.创建类型限定类型(KSK.共享_, fc.创建括号类型(.实例化类型(type.类型)));
        }
        else {
            新节点 = .实例化类型(type.类型);
        }
        return 新节点;
    }
    if ((type.复合标志 & 复合标志_.内置类型字面量_) != 0) {
        类型_ 基类型 = 获取字面量类型的基约束类型(type);
        if (基类型 != type) {
            return .实例化类型(基类型);
        }
    }
    if ((type.标志 & 类型标志_.联合_) != 0 && (type.标志 & 类型标志_.枚举字面量_) != 0 || (type.标志 & 类型标志_.枚举_) != 0) {
        符号_ 符号 = (cast(符号_)(type.符号));
        if (符号 !is ··null!(符号_)) {
            return .实例化类型(符号.枚举基类型);
        }
    }
    if ((type.标志 & 类型标志_.枚举字面量_) != 0 && (type.标志 & 类型标志_.联合_) == 0) {
        符号_ parentSymbol = 获取父符号((cast(符号_)(type.符号)));
        return .实例化类型(parentSymbol.枚举基类型);
    }
    if ((type.标志 & 类型标志_.未知_) != 0) {
        return fc.创建关键字类型节点(KSK.未知_);
    }
    if ((type.标志 & 类型标志_.任意_) != 0) {
        return fc.创建指针类型(fc.创建关键字类型节点(KSK.无值_));
    }
    if ((type.标志 & 类型标志_.不及_) != 0) {
        return fc.创建关键字类型节点(KSK.无值_);
    }
    if ((type.标志 & 类型标志_.无值_) != 0) {
        return fc.创建关键字类型节点(KSK.无值_);
    }
    if ((type.标志 & 类型标志_.空值_) != 0) {
        if ((type.复合标志 & 复合标志_.空址_) != 0) {
            return fc.创建关键字类型节点(KSK.空址_);
        }
        if ((type.复合标志 & 复合标志_.零值_) != 0) {
            return fc.创建关键字类型节点(KSK.零值_);
        }
        return fc.创建关键字类型节点(KSK.空值_);
    }
    if ((type.标志 & 类型标志_.字节_) != 0) {
        return fc.创建关键字类型节点(KSK.字节_);
    }
    if ((type.标志 & 类型标志_.真字面量_) != 0) {
        return fc.创建关键字类型节点(KSK.真_);
    }
    if ((type.标志 & 类型标志_.假字面量_) != 0) {
        return fc.创建关键字类型节点(KSK.假_);
    }
    if ((type.标志 & 类型标志_.真假_) != 0) {
        return fc.创建关键字类型节点(KSK.真假_);
    }
    if ((type.标志 & 类型标志_.文本8_) != 0) {
        return fc.创建关键字类型节点(KSK.文本8_);
    }
    if ((type.标志 & 类型标志_.文本16_) != 0) {
        return fc.创建关键字类型节点(KSK.文本16_);
    }
    if ((type.标志 & 类型标志_.文本32_) != 0) {
        return fc.创建关键字类型节点(KSK.文本_);
    }
    if ((type.标志 & 类型标志_.字符8_) != 0) {
        return fc.创建关键字类型节点(KSK.字符8_);
    }
    if ((type.标志 & 类型标志_.字符16_) != 0) {
        return fc.创建关键字类型节点(KSK.字符16_);
    }
    if ((type.标志 & 类型标志_.字符32_) != 0) {
        return fc.创建关键字类型节点(KSK.字符_);
    }
    if ((type.标志 & 类型标志_.整数8_) != 0) {
        return fc.创建关键字类型节点(KSK.整数8_);
    }
    if ((type.标志 & 类型标志_.整数16_) != 0) {
        return fc.创建关键字类型节点(KSK.整数16_);
    }
    if ((type.标志 & 类型标志_.整数32_) != 0) {
        return fc.创建关键字类型节点(KSK.整数32_);
    }
    if ((type.标志 & 类型标志_.整数64_) != 0) {
        return fc.创建关键字类型节点(KSK.整数_);
    }
    if ((type.标志 & 类型标志_.正整数8_) != 0) {
        return fc.创建关键字类型节点(KSK.正整数8_);
    }
    if ((type.标志 & 类型标志_.正整数16_) != 0) {
        return fc.创建关键字类型节点(KSK.正整数16_);
    }
    if ((type.标志 & 类型标志_.正整数32_) != 0) {
        return fc.创建关键字类型节点(KSK.正整数32_);
    }
    if ((type.标志 & 类型标志_.正整数64_) != 0) {
        return fc.创建关键字类型节点(KSK.正整数_);
    }
    if ((type.标志 & 类型标志_.小数32_) != 0) {
        return fc.创建关键字类型节点(KSK.小数32_);
    }
    if ((type.标志 & 类型标志_.小数64_) != 0) {
        return fc.创建关键字类型节点(KSK.小数_);
    }
    if ((type.标志 & 类型标志_.虚数32_) != 0) {
        return fc.创建关键字类型节点(KSK.虚数32_);
    }
    if ((type.标志 & 类型标志_.虚数64_) != 0) {
        return fc.创建关键字类型节点(KSK.虚数_);
    }
    if ((type.标志 & 类型标志_.复数64_) != 0) {
        return fc.创建关键字类型节点(KSK.复数64_);
    }
    if ((type.标志 & 类型标志_.复数128_) != 0) {
        return fc.创建关键字类型节点(KSK.复数_);
    }
    if ((type.标志 & 类型标志_.复合_) != 0) {
        if ((type.复合标志 & 复合标志_.数组_) != 0) {
            节点_ 类型_ = .实例化类型(type.类型);
            节点_ 长度_ = .实例化类型(type.长度);
            return fc.创建数组类型(类型_, 长度_);
        }
        if ((type.复合标志 & 复合标志_.动态_) != 0) {
            节点_ 类型_ = .实例化类型(type.类型);
            return fc.创建动态数组类型(类型_);
        }
        if ((type.复合标志 & 复合标志_.变长_) != 0) {
            节点_ 类型_ = .实例化类型(type.类型);
            return fc.创建变长参数(类型_);
        }
        if ((type.复合标志 & 复合标志_.列表_) != 0) {
            节点_[] 类型组 = 创建数组!(节点_)();
            foreach (类型_ t; type.类型.类型组) {
                节点_ 类型_ = .实例化类型(t);
                .追加!(节点_)(类型组, 类型_);
            }
            return fc.创建元组类型节点(fc.f·创建节点数组!(节点_)(new 节点数组_!(节点_)(类型组)));
        }
        if ((type.复合标志 & 复合标志_.词典_) != 0) {
            节点_[] 类型组 = 创建数组!(节点_)();
            foreach (类型_ t; type.类型组) {
                节点_ 类型_ = .实例化类型(t);
                .追加!(节点_)(类型组, 类型_);
            }
            assert(类型组.length == 2, "词典键值类型错误"c);
            return fc.创建词典类型(类型组[0], 类型组[1]);
        }
        if ((type.复合标志 & 复合标志_.元组_) != 0) {
            节点_[] 类型组 = 创建数组!(节点_)();
            foreach (类型_ t; type.类型组) {
                节点_ 类型_ = .实例化类型(t);
                .追加!(节点_)(类型组, 类型_);
            }
            return fc.创建元组类型节点(fc.f·创建节点数组!(节点_)(new 节点数组_!(节点_)(类型组)));
        }
        if ((type.复合标志 & 复合标志_.指针_) != 0) {
            return fc.创建括号类型(fc.创建指针类型(.实例化类型(type.类型)));
        }
    }
    if ((type.标志 & 类型标志_.可选类型_) != 0) {
        return .实例化类型(type.类型);
    }
    if ((type.复合标志 & 复合标志_.泛型引用_) != 0) {
        类型_[] 类型实参组 = getTypeArguments(type);
        dstring[] 类型实参文本组 = 创建数组!(dstring)();
        foreach (类型_ t; 类型实参组) {
            节点_ tn = .实例化类型(t);
            .追加!(dstring)(类型实参文本组, .打印类型(tn));
        }
        dstring 名称 = .获取符号名(type.泛型目标.符号);
        dstring 中间 = "."d ~ 名称;
        if (类型实参文本组.length > 1) {
            dstring 实参文本 = 连接(类型实参文本组, ","d);
            中间 = 中间 ~ "!("d ~ 实参文本 ~ ")"d;
        }
        else if (类型实参文本组.length == 1) {
            中间 = 中间 ~ "!"d ~ 类型实参文本组[0];
        }
        else {
            中间 = ""d;
        }
        dstring 前面 = .生成父符号名称((cast(符号_)(type.泛型目标.符号)));
        名称 = 前面 ~ 中间 ~ "."d ~ 名称;
        限定名_ 类型名 = fc.创建起始限定名(fc.创建文本标识符(名称));
        类型引用_ 新名称的引用类型 = fc.创建类型引用(类型名);
        .获取合成节点扩展(新名称的引用类型).解析类型 = type;
        return 新名称的引用类型;
    }
    return 返回零值!(节点_)();
}
打印机_ 创建类型打印机() {
    if (.打印机 is ··null!(打印机_)) {
        Klang打印选项_ 打印选项 = new Klang打印选项_(Klang输出种类_.无_);
        打印助手_ 打印助手 = 打印助手_();
        打印选项.removeComments = true;
        .打印机 = 创建打印机(打印选项, 打印助手);
    }
    return .打印机;
}
dstring 打印类型(节点_ tn) {
    EmitTextWriter 文本写 = 创建文本写(""d);
    打印机_ 类型打印机 = .创建类型打印机();
    类型打印机.writeNode(EmitHint.Unspecified, tn, 返回零值!(基础源文件_)(), 文本写);
    dstring result = 文本写.getText();
    文本写.clear();
    return result;
}
dstring 生成父符号名称(符号_ 符号) {
    void delegate(符号_) 内部计算;
    dstring[] name;
    void 内部计算·func(符号_ s) {
        符号_ p;
        p = (cast(符号_)(s.父符号));
        if (p !is ··null!(符号_)) {
            if ((p.标志 & 符号标志_.程序集_) != 0) {
                name = .追加!(dstring)(p.碎裂名称[0 .. $], name);
            }
            else {
                name = .追加!(dstring)([.获取符号名(p)], name);
                内部计算(p);
            }
        }
        return;
    }
    内部计算 = &内部计算·func;
    if (符号.碎裂名称 !is ··null!(dstring[])) {
        return 连接(符号.碎裂名称, "."d);
    }
    name = 创建数组!(dstring)();
    内部计算(符号);
    符号.碎裂名称 = name;
    return 连接(name, "."d);
}
dstring 获取符号名(基础符号_ s) {
    long i = 从后查找字符索引(s.名称, cast(dchar)'|');
    if (i != -1) {
        return s.名称[i .. $];
    }
    return s.名称;
}
dstring 输出编码及长度(dstring name, ref ulong 长) {
    ubyte[] data = (cast(ubyte[])(·to!(string)(name)));
    长 = data.length;
    return ._编码输出(data);
}
dstring 编码输出(dstring name) {
    ubyte[] data = (cast(ubyte[])(·to!(string)(name)));
    return ._编码输出(data);
}
dstring _编码输出(ubyte[] data) {
    dchar[] str = 创建数组!(dchar)();
    foreach (ubyte ch; data) {
        if (ch > 126 || ch < 32) {
            ubyte a = ch / 16;
            ubyte b = ch % 16;
            .追加!(dchar)(str, 字符_.反斜杠);
            .追加!(dchar)(str, 十六进制编码(a));
            .追加!(dchar)(str, 十六进制编码(b));
        }
        else {
            .追加!(dchar)(str, ch);
        }
    }
    return ·to!(dstring)(str);
}
